The technology described herein relates to graphics processing systems and in particular to overlay rendering and similar operations in graphics processing systems.
As is known in the art, the output of a graphics processing system to be displayed is usually written to a so-called “frame buffer” in memory when it is ready for display. The frame buffer is then read by a display controller and output to the display (which may, e.g., be a screen or a printer) for display.
One operation that may be required of a graphics processing system is to add (render) an overlay to some existing image. In this case, the existing image will be read back in from the frame buffer (for example), modified to show the overlaid image, and then written back to the frame buffer for display.
Where this is to be done in a tile-based rendering system, tiles of data in the existing image to be overlaid will accordingly be read into the tile buffer (local memory) of the renderer, modified appropriately, and then written back out to the appropriate render output target (e.g. the frame buffer).
(As is known in the art, in tile-based rendering, the two dimensional output array of the rendering process (the “render target”) (e.g., and typically, that will be displayed to display the scene being rendered) is sub-divided or partitioned into a plurality of smaller regions, usually referred to as “tiles”, for the rendering process. The tiles (sub-regions) are each rendered separately (typically one after another). The rendered tiles (sub-regions) are then recombined to provide the complete output array (frame) (render target), e.g. for display.
Other terms that are commonly used for “tiling” and “tile based” rendering include “chunking” (the sub-regions are referred to as “chunks”) and “bucket” rendering. The terms “tile” and “tiling” will be used herein for convenience, but it should be understood that these terms are intended to encompass all alternative and equivalent terms and techniques.)
The writing of graphics data to and the reading of graphics data from the frame buffer (or other output buffer) consumes a relatively significant amount of power and memory bandwidth, particularly where, as is typically the case, the frame buffer resides in memory that is external to the graphics processor. Each frame can require a significant amount of data, particularly for higher resolution displays and high definition (HD) graphics.
As overlay rendering operations require reading and writing data to and from the frame buffer (or other external render target), they can accordingly consume a relatively large amount of memory bandwidth.
The Applicants believe therefore that there is scope for improvements to such operations in graphics processing systems, and in particular in tile-based graphics processing systems.
Like reference numerals are used for like features throughout the figures (where appropriate).